﻿#include<iostream>
#include<stack>
#include <string>
#include <list>
#include <math.h>
#include<vector>

using namespace std;


//第一题：字符串转整形数字
// 
//请你来实现一个 myAtoi(string s) 函数，
//使其能将字符串转换成一个 32 位有符号整数（类似 C / C++ 中的 atoi 函数）。
//函数 myAtoi(string s) 的算法如下：
//读入字符串并丢弃无用的前导空格
//检查下一个字符（假设还未到字符末尾）为正还是负号，读取该字符（如果有）。 
//确定最终结果是负数还是正数。 如果两者都不存在，则假定结果为正。
//读入下一个字符，直到到达下一个非数字字符或到达输入的结尾。字符串的其余部分将被忽略。
//将前面步骤读入的这些数字转换为整数（即，"123" -> 123， "0032" -> 32）。
//如果没有读入数字，则整数为 0 。必要时更改符号（从步骤 2 开始）。
//如果整数数超过 32 位有符号整数范围[−231, 231 − 1] ，
//需要截断这个整数，使其保持在这个范围内。
//具体来说，小于 −231 的整数应该被固定为 −231 ，大于 231 − 1 的整数应该被固定为 231 − 1 。
//返回整数作为最终结果。
//示例
//输入：s = "4193 with words"
//输出：4193
//解释：
//第 1 步："4193 with words"（当前没有读入字符，因为没有前导空格）
//第 2 步："4193 with words"（当前没有读入字符，因为这里不存在 '-' 或者 '+'）
//第 3 步："4193 with words"（读入 "4193"；由于下一个字符不是一个数字，所以读入停止）
//解析得到整数 4193 。
//由于 "4193" 在范围[-231, 231 - 1] 内，最终结果为 4193 。
//
//class Solution0 {
//public:
//    bool biggerorequal(string str1, string str2)
//    {
//        if (str1.size() > str2.size())
//        {
//            return true;
//        }
//        else if (str1.size() == str2.size())
//        {
//            for (int i = 0; i < str1.size(); i++)
//            {
//                if (str1[i] < str2[i])
//                {
//                    return false;
//                }
//                else if (str1[i] > str2[i])
//                {
//                    return true;
//                }
//            }
//            return true;
//        }
//        else
//        {
//            return false;
//        }
//    }   
//    int myAtoi(string str) {
//        string retstr;
//        int ret = 0;
//        for (int i = 0; i < str.size(); i++)
//        {
//            char tmp = str[i];
//            if (!((tmp == '-') || (tmp == '+') || (47 < tmp) && (tmp < 58)) && (tmp != ' '))
//                return 0;
//            if ((tmp == '-') || (tmp == '+') || (47 < tmp) && (tmp < 58))
//            {
//                retstr.push_back(str[i]);
//                int j = i + 1;
//                if (j < str.size())
//                {
//                    tmp = str[j];
//                    while ((47 < tmp) && (tmp < 58) || tmp == '.')
//                    {
//                        if (tmp == ' ')
//                        {
//                            return 0;
//                        }
//                        retstr.push_back(tmp);
//                        if (j + 1 >= str.size())
//                            break;
//                        tmp = str[++j];
//                    }
//                    break;
//                }
//                else
//                {
//                    if ((tmp == '-') || (tmp == '+'))
//                    {
//                        return 0;
//                    }
//                    else
//                    {
//                        return tmp - 48;
//                    }
//                }
//            }
//        }
//        int countnotnum = retstr.size();
//        int flag = 0;
//        if (retstr[0] == '-')
//        {
//            flag = 1;
//        }
//        for (size_t i = 0; i < retstr.size(); i++)
//        {
//            int val = ((int)retstr[i]) - 48;
//            if (val == -2)
//            {
//                countnotnum -= (retstr.size() - i);
//                break;
//            }
//            else if ((val == -3) || (val == -5))
//            {
//                retstr.erase(i, 1);
//                countnotnum--;
//            }
//            else if (!((0 <= val) && (val <= 9)))
//            {
//                countnotnum--;
//            }
//        }
//        if (retstr[0] == '0')
//        {
//            while ((retstr[0] == '0') && retstr.size())
//            {
//                int val = ((int)retstr[0]) - 48;
//                if (val == 0)
//                {
//                    retstr.erase(0, 1);
//                    countnotnum--;
//                    if (countnotnum == 0)
//                    {
//                        return 0;
//                    }
//                }
//            }
//        }
//        string cmp("2147483648");
//        if (flag && biggerorequal(retstr, cmp))
//        {
//            return -2147483648;
//        }
//        else if ((flag == 0) && biggerorequal(retstr, cmp))
//        {
//            return 2147483647;
//        }
//        for (size_t i = 0; i < countnotnum; i++)
//        {
//            int val = ((int)retstr[i]) - 48;
//            if ((0 <= val) && (val <= 9))
//            {
//                ret += val * pow(10, (countnotnum - i - 1));
//            }
//        }
//        if (flag)
//        {
//            return ret * (-1);
//        }
//        return ret;
//    }
//};
//
////第二题：字符串相加
//// 
//// 给定两个字符串形式的非负整数 num1 和num2 ，
//// 计算它们的和并同样以字符串形式返回。
////你不能使用任何內建的用于处理大整数的库（比如 BigInteger）， 
////也不能直接将输入的字符串转换为整数形式。
////示例 ：
////输入：num1 = "11", num2 = "123"
////输出："134"
//
////这个题有三种思路：
////    1. 将num1 和 num2转换成整数，相加后再返回其结果
////       缺陷：C/C++中，不能存下任意大的数字
////    2. 按照竖式计算，将每一位进行相加后判断进位，
////       将该位置处的数字  通过 insert() 方法头插到新的 string 对象中
////       缺陷：由于string中的字符存储都是按照顺序表的形式
////             所以每调用一次insert()，都会将当前字符串的所有元素向后移动
////             这将导致算法的时间复杂度较高，
////       注意：这也说明了在程序的循环中，尽量少的调用insert / replace / erase 方法的原因
////    3. 按照竖式计算，将每一位进行相加后判断进位，
////       将该位置处的数字  通过 push_back 或 += 尾插到新的 string 对象中，
////       最后再进行反转，可以使用reverse这个通用模板
////       注意：reverse中的两个参数需要传入迭代器，这两个参数形成一个左闭右开的迭代区间
//class Solution {
//public:
//    void reversestring(string& num)
//    {
//        int left = 0;
//        int right = num.size() - 1;
//        while (left < right)
//        {
//            swap(num[left], num[right]);
//            left++;
//            right--;
//        }
//    }
//    string addStrings(string num1, string num2) {
//        //int ret1 = 0;
//        //int ret2 = 0;
//        //int countDigit = 0;
//        //char retstr[10000] = { 0 };
//        //
//        //for (size_t i = 0; i < num1.size(); i++)
//        //{
//        //    int digit = ((int)num1[i]) - 48;
//        //    ret1 += digit * pow(10, (num1.size() - i - 1));
//        //}
//        //for (size_t i = 0; i < num2.size(); i++)
//        //{
//        //    int digit = ((int)num2[i]) - 48;
//        //    ret2 += digit * pow(10, (num2.size() - i - 1));
//        //}
//        //int tmpret = ret1 + ret2;
//        //int ret = tmpret;
//        //if (ret == 0)
//        //{
//        //    string numRet("0");
//        //    return numRet;
//        //}
//        //while (tmpret)
//        //{
//        //    countDigit++;
//        //    tmpret /= 10;
//        //}
//        //while (countDigit--)
//        //{
//        //    retstr[countDigit] = ret % 10 + '0';
//        //    ret /= 10;
//        //}
//        //string numret(retstr);
//        //return numret;
//        
//        int flag = 0;
//        int digit = 0;
//        char digitchar = '0';
//        string retnum;
//        int i = num1.size() - 1;
//        int j = num2.size() - 1;
//        while (i >= 0 || j >= 0)
//        {
//            if (j < 0)
//            {
//                digit = (int)num1[i] - 48;
//            }
//            else if (i < 0)
//            {
//                digit = (int)num2[j] - 48;
//            }
//            else
//            {
//                digit = (int)num1[i] - 48 + (int)num2[j] - 48;
//            }
//            if ((digit + flag) >= 10)
//            {
//                digitchar = (digit + flag) % 10 + '0';
//                flag = 1;
//            }
//            else
//            {
//                digitchar = digit + flag + '0';
//                flag = 0;
//            }
//            retnum.push_back(digitchar);
//            i--;
//            j--;
//        }
//        if (flag)
//        {
//            retnum.push_back('1');
//        }
//        reversestring(retnum);
//        return retnum;
//    }
//};
//
////第三题：翻转字符串
////编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。
////不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
//
//class Solution1 {
//public:
//    void reverseString(vector<char>& s) {
//        int left = 0;
//        int right = s.size() - 1;
//        while (left < right)
//        {
//            swap(s[left], s[right]);
//            left++;
//            right--;
//        }
//    }
//};
//
////第四题：字符串中的第一个唯一字符
////给定一个字符串 s ，找到 它的第一个不重复的字符，并返回它的索引 。如果不存在，则返回 - 1 。
////示例 1：
////输入 : s = "leetcode"
////输出 : 0
//class Solution2 {
//public:
//    int firstUniqChar(string s) {
//        for (int i = 0; i < s.size(); i++)
//        {
//            int subofprev = s.find(s[i], 0);
//            int subofnext = s.find(s[i], i + 1);
//            if ((subofprev == i) && (subofnext == string::npos))
//            {
//                return i;
//            }
//        }
//        return -1;
//    }
//};
//
////第五题：验证一个字符串是否是回文
////如果在将所有大写字符转换为小写字符、并移除所有非字母数字字符之后，
////短语正着读和反着读都一样。则可以认为该短语是一个 回文串 。
////字母和数字都属于字母数字字符。
////给你一个字符串 s，如果它是 回文串 ，返回 true ；否则，返回 false 。
////示例 1：
////输入 : s = "A man, a plan, a canal: Panama"
////输出：true
////解释："amanaplanacanalpanama" 是回文串。
//class Solution3 {
//public:
//    void removeotherchar(string& s)
//    {
//        for (int i = 0; i < s.size(); i++)
//        {
//            int ascval = (int)s[i];
//            if ((64 < ascval) && (ascval < 91))
//            {
//                s[i] += 32;
//            }
//            if (!(((64 < ascval) && (ascval < 91)) 
//                || ((96 < ascval) && (ascval < 123)) 
//                || ((47 < ascval) && (ascval < 58))))
//            {
//                s.erase(i, 1);
//                i--;
//            }
//        }
//    }
//    bool isPalindrome(string s) {
//        removeotherchar(s);
//        int left = 0;
//        int right = s.size() - 1;
//        while (left <= right)
//        {
//            if (s[left] != s[right])
//            {
//                return 0;
//            }
//            left++;
//            right--;
//        }
//        return 1;
//    }
//};
//
//int main()
//{
//    //string str("4193 with words");
//    //string str("   -42");
//    //string str("-91283472332");
//    //string str("   +0 123");
//    //string str("-2147483648");
//    //string str("  0000000000012345678");
//    //string str("  00000000000");
//    //string str("1");
//    string str("1095502006p8");
//    Solution0 solu;
//    int ret = solu.myAtoi(str);
//
//    //string num1("6913259244");
//    //string num2("71103343");
//    //Solution solu1;
//    //string ret = solu1.addStrings(num1, num2);
//
//    //string s("loveleetcode");
//    //Solution2 solu2;
//    //int ret = solu2.firstUniqChar(s);
//
//    //string s("A man, a plan, a canal: Panama");
//    //Solution3 solu;
//    //bool ret = solu.isPalindrome(s);
//
//	return 0;
//}

int main()
{
	string ss;
	const char* str = "sadjiawo";
	char buf[20];

	cout << typeid(ss.c_str()).name() << endl;
	cout << typeid(str).name() << endl;
	cout << typeid(buf).name() << endl;

	//getline(cin, ss);
	//cin.getline(str, 10);
	cin.getline(buf, 10);
	ss = buf;

	cout << ss << endl;

	return 0;
}
